{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:19.613733Z",
     "start_time": "2025-01-26T14:14:15.105180Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:21.520250Z",
     "start_time": "2025-01-26T14:14:19.614741Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:21.525717Z",
     "start_time": "2025-01-26T14:14:21.521251Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "# print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])\n",
    ")\n"
   ],
   "outputs": [],
   "execution_count": 3
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:21.543761Z",
     "start_time": "2025-01-26T14:14:21.526719Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),  # in_features=784, out_features=300\n",
    "            nn.ReLU(),\n",
    "            nn.AlphaDropout(p=0.2) # 增加dropout，p=0.2表示以0.2的概率将某些神经元置0，防止过拟合\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "            # 增加dropout,alphaDropout不改变参数的均值和方差\n",
    "            self.linear_relu_stack.add_module(f\"Dropout_{i}\", nn.AlphaDropout(p=0.2))\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "print(f\"{'layer_name':^40}\\tparamerters num\")\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(\"{:<40}\\t{:^10}\".format(key, np.prod(value.shape)))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               layer_name               \tparamerters num\n",
      "linear_relu_stack.0.weight              \t  78400   \n",
      "linear_relu_stack.0.bias                \t   100    \n",
      "linear_relu_stack.Linear_1.weight       \t  10000   \n",
      "linear_relu_stack.Linear_1.bias         \t   100    \n",
      "linear_relu_stack.Linear_2.weight       \t  10000   \n",
      "linear_relu_stack.Linear_2.bias         \t   100    \n",
      "linear_relu_stack.Linear_3.weight       \t  10000   \n",
      "linear_relu_stack.Linear_3.bias         \t   100    \n",
      "linear_relu_stack.Linear_4.weight       \t  10000   \n",
      "linear_relu_stack.Linear_4.bias         \t   100    \n",
      "linear_relu_stack.Linear_5.weight       \t  10000   \n",
      "linear_relu_stack.Linear_5.bias         \t   100    \n",
      "linear_relu_stack.Linear_6.weight       \t  10000   \n",
      "linear_relu_stack.Linear_6.bias         \t   100    \n",
      "linear_relu_stack.Linear_7.weight       \t  10000   \n",
      "linear_relu_stack.Linear_7.bias         \t   100    \n",
      "linear_relu_stack.Linear_8.weight       \t  10000   \n",
      "linear_relu_stack.Linear_8.bias         \t   100    \n",
      "linear_relu_stack.Linear_9.weight       \t  10000   \n",
      "linear_relu_stack.Linear_9.bias         \t   100    \n",
      "linear_relu_stack.Linear_10.weight      \t  10000   \n",
      "linear_relu_stack.Linear_10.bias        \t   100    \n",
      "linear_relu_stack.Linear_11.weight      \t  10000   \n",
      "linear_relu_stack.Linear_11.bias        \t   100    \n",
      "linear_relu_stack.Linear_12.weight      \t  10000   \n",
      "linear_relu_stack.Linear_12.bias        \t   100    \n",
      "linear_relu_stack.Linear_13.weight      \t  10000   \n",
      "linear_relu_stack.Linear_13.bias        \t   100    \n",
      "linear_relu_stack.Linear_14.weight      \t  10000   \n",
      "linear_relu_stack.Linear_14.bias        \t   100    \n",
      "linear_relu_stack.Linear_15.weight      \t  10000   \n",
      "linear_relu_stack.Linear_15.bias        \t   100    \n",
      "linear_relu_stack.Linear_16.weight      \t  10000   \n",
      "linear_relu_stack.Linear_16.bias        \t   100    \n",
      "linear_relu_stack.Linear_17.weight      \t  10000   \n",
      "linear_relu_stack.Linear_17.bias        \t   100    \n",
      "linear_relu_stack.Linear_18.weight      \t  10000   \n",
      "linear_relu_stack.Linear_18.bias        \t   100    \n",
      "linear_relu_stack.Linear_19.weight      \t  10000   \n",
      "linear_relu_stack.Linear_19.bias        \t   100    \n",
      "linear_relu_stack.Output Layer.weight   \t   1000   \n",
      "linear_relu_stack.Output Layer.bias     \t    10    \n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:21.621873Z",
     "start_time": "2025-01-26T14:14:21.544763Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:26.421337Z",
     "start_time": "2025-01-26T14:14:21.621873Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:26.426721Z",
     "start_time": "2025-01-26T14:14:26.422343Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:14:26.434423Z",
     "start_time": "2025-01-26T14:14:26.426721Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:38:36.015495Z",
     "start_time": "2025-01-26T14:14:26.435427Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/dropout\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/dropout\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "a9650ee9be9a4d86aab7c1056ac6bfc3"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 80 / global_step 300000\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:38:36.342064Z",
     "start_time": "2025-01-26T14:38:36.015495Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:44:27.799745Z",
     "start_time": "2025-01-26T14:44:26.818326Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "#推理时alphadropout的p值是0，通过加dropout，一定程度解决了过拟合\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/dropout/best.ckpt\",weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     7.9349\n",
      "accuracy: 0.8659\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-26T14:38:37.278876Z",
     "start_time": "2025-01-26T14:38:37.276729Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "outputs": [],
   "execution_count": 11
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
